package com.javaee.wordtree.service;

import com.javaee.wordtree.common.CircleData;
import com.javaee.wordtree.common.ColumnData;
import com.javaee.wordtree.common.LineData;
import com.javaee.wordtree.entity.Word;
import com.javaee.wordtree.mapper.MmryRecordMapper;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * 学习分析服务 - 结合大模型进行背诵分析
 * 
 * @author AI Assistant
 */
@Service
@Slf4j
public class LearningAnalysisService {

    @Resource
    private StatisticService statisticService;

    @Resource
    private MemoryService memoryService;

    @Resource
    private DeepseekService deepseekService;

    @Resource
    private MmryRecordMapper mmryRecordMapper;

    /**
     * 生成个性化的学习分析报告
     * 
     * @param userID     用户ID
     * @param belongBook 所属词书
     * @return 分析报告文本
     */
    public String generateLearningAnalysisReport(String userID, String belongBook) {
        try {
            // 1. 收集用户学习数据
            String learningData = collectUserLearningData(userID, belongBook);

            // 2. 构建分析提示词
            String analysisPrompt = buildAnalysisPrompt(learningData);

            // 3. 调用大模型进行分析
            return deepseekService.callDeepseekApi(analysisPrompt)
                    .map(response -> {
                        if (response.getChoices() != null && !response.getChoices().isEmpty()) {
                            return response.getChoices().get(0).getMessage().getContent();
                        }
                        return "分析报告生成失败，请稍后再试。";
                    })
                    .onErrorReturn("AI分析服务暂时不可用，请稍后再试。")
                    .block();

        } catch (Exception e) {
            log.error("生成学习分析报告失败: {}", e.getMessage(), e);
            return "分析报告生成失败，请检查网络连接。";
        }
    }

    /**
     * 生成个性化的学习建议
     * 
     * @param userID     用户ID
     * @param belongBook 所属词书
     * @return 学习建议文本
     */
    public String generateLearningAdvice(String userID, String belongBook) {
        try {
            // 1. 收集用户学习数据
            String learningData = collectUserLearningData(userID, belongBook);

            // 2. 获取用户学习困难点
            String difficulties = analyzeLearningDifficulties(userID);

            // 3. 构建建议提示词
            String advicePrompt = buildAdvicePrompt(learningData, difficulties);

            // 4. 调用大模型生成建议
            return deepseekService.callDeepseekApi(advicePrompt)
                    .map(response -> {
                        if (response.getChoices() != null && !response.getChoices().isEmpty()) {
                            return response.getChoices().get(0).getMessage().getContent();
                        }
                        return "学习建议生成失败，请稍后再试。";
                    })
                    .onErrorReturn("AI建议服务暂时不可用，请稍后再试。")
                    .block();

        } catch (Exception e) {
            log.error("生成学习建议失败: {}", e.getMessage(), e);
            return "学习建议生成失败，请检查网络连接。";
        }
    }

    /**
     * 预测遗忘风险并提供预警
     * 
     * @param userID 用户ID
     * @return 遗忘风险分析
     */
    public String predictForgettingRisk(String userID) {
        try {
            // 1. 获取用户记忆数据
            List<CircleData> memoryData = statisticService.findMmryPercentage(userID);
            List<Word> needReviewWords = memoryService.getNeedReviewWords(userID);

            // 2. 构建遗忘风险分析提示词
            String riskPrompt = buildForgettingRiskPrompt(memoryData, needReviewWords);

            // 3. 调用大模型分析遗忘风险
            return deepseekService.callDeepseekApi(riskPrompt)
                    .map(response -> {
                        if (response.getChoices() != null && !response.getChoices().isEmpty()) {
                            return response.getChoices().get(0).getMessage().getContent();
                        }
                        return "遗忘风险分析失败，请稍后再试。";
                    })
                    .onErrorReturn("AI风险分析服务暂时不可用，请稍后再试。")
                    .block();

        } catch (Exception e) {
            log.error("预测遗忘风险失败: {}", e.getMessage(), e);
            return "遗忘风险分析失败，请检查网络连接。";
        }
    }

    /**
     * 收集用户学习数据
     */
    private String collectUserLearningData(String userID, String belongBook) {
        StringBuilder dataBuilder = new StringBuilder();

        // 基础统计数据
        int learnedCount = statisticService.getLearnedWordCount(userID);
        int totalCount = statisticService.getTotalWordCount(belongBook);
        int reviewCount = statisticService.getNeedReviewWordCount(userID);

        dataBuilder.append("用户学习基本情况：\n");
        dataBuilder.append("- 已学单词数量：").append(learnedCount).append("个\n");
        dataBuilder.append("- 词书总单词数：").append(totalCount).append("个\n");
        dataBuilder.append("- 学习进度：").append(String.format("%.1f", (double) learnedCount / totalCount * 100))
                .append("%\n");
        dataBuilder.append("- 待复习单词数：").append(reviewCount).append("个\n\n");

        // 最近7天学习数据
        List<ColumnData> recentData = statisticService.findLatestSevenDaysWordData(userID);
        dataBuilder.append("最近7天学习情况：\n");
        Map<String, List<ColumnData>> groupedData = recentData.stream()
                .collect(Collectors.groupingBy(ColumnData::getType));

        if (groupedData.containsKey("Learn")) {
            int totalLearned = groupedData.get("Learn").stream().mapToInt(ColumnData::getValue).sum();
            dataBuilder.append("- 新学单词总数：").append(totalLearned).append("个\n");
        }

        if (groupedData.containsKey("Review")) {
            int totalReviewed = groupedData.get("Review").stream().mapToInt(ColumnData::getValue).sum();
            dataBuilder.append("- 复习单词总数：").append(totalReviewed).append("个\n");
        }

        // 学习时长数据
        List<LineData> timeData = statisticService.findLatestSevenDaysTimeData(userID);
        int totalTime = timeData.stream().mapToInt(LineData::getTime).sum();
        dataBuilder.append("- 总学习时长：").append(totalTime).append("分钟\n");
        dataBuilder.append("- 平均每日学习时长：").append(totalTime / 7).append("分钟\n\n");

        // 记忆阶段分布
        List<CircleData> memoryData = statisticService.findMmryPercentage(userID);
        dataBuilder.append("单词记忆阶段分布：\n");
        for (CircleData data : memoryData) {
            dataBuilder.append("- ").append(data.getType()).append("：").append(String.format("%d", data.getValue()))
                    .append("%\n");
        }

        return dataBuilder.toString();
    }

    /**
     * 分析学习困难点
     */
    private String analyzeLearningDifficulties(String userID) {
        StringBuilder difficulties = new StringBuilder();

        // 获取需要复习的单词数量，如果过多说明有困难
        int reviewCount = statisticService.getNeedReviewWordCount(userID);
        if (reviewCount > 50) {
            difficulties.append("- 复习单词积压较多（").append(reviewCount).append("个），可能存在遗忘问题\n");
        }

        // 分析记忆阶段分布，低阶段占比过高说明有困难
        List<CircleData> memoryData = statisticService.findMmryPercentage(userID);
        float lowStagePercentage = 0;
        for (CircleData data : memoryData) {
            if (data.getPhase() <= 2) { // 认识、了解阶段
                lowStagePercentage += data.getValue();
            }
        }

        if (lowStagePercentage > 60) {
            difficulties.append("- 大部分单词仍处于初级记忆阶段（").append(String.format("%.1f", lowStagePercentage))
                    .append("%），需要加强复习\n");
        }

        // 分析学习时长稳定性
        List<LineData> timeData = statisticService.findLatestSevenDaysTimeData(userID);
        long zeroTimeCount = timeData.stream().filter(data -> data.getTime() == 0).count();
        if (zeroTimeCount >= 3) {
            difficulties.append("- 学习时间不规律，7天内有").append(zeroTimeCount).append("天未学习\n");
        }

        if (difficulties.length() == 0) {
            difficulties.append("- 学习状态良好，无明显困难点\n");
        }

        return difficulties.toString();
    }

    /**
     * 构建学习分析提示词
     */
    private String buildAnalysisPrompt(String learningData) {
        return "你是一位专业的英语学习分析师，请根据以下用户学习数据，生成一份详细的学习分析报告。\n\n" +
                "学习数据：\n" + learningData + "\n\n" +
                "请从以下几个方面进行分析：\n" +
                "1. 学习进度评估\n" +
                "2. 学习效率分析\n" +
                "3. 记忆效果评价\n" +
                "4. 学习习惯观察\n" +
                "5. 优势与不足总结\n\n" +
                "要求：\n" +
                "- 分析要客观、具体，有数据支撑\n" +
                "- 语言要专业但易懂\n" +
                "- 提供具体的量化指标解读\n" +
                "- 总字数控制在500字以内\n" +
                "- 使用中文回复";
    }

    /**
     * 构建学习建议提示词
     */
    private String buildAdvicePrompt(String learningData, String difficulties) {
        return "你是一位资深的英语学习顾问，请根据用户的学习数据和困难点，提供个性化的学习建议。\n\n" +
                "学习数据：\n" + learningData + "\n\n" +
                "识别的困难点：\n" + difficulties + "\n\n" +
                "请提供以下方面的建议：\n" +
                "1. 学习计划优化建议\n" +
                "2. 复习策略调整\n" +
                "3. 时间管理建议\n" +
                "4. 记忆技巧推荐\n" +
                "5. 具体的行动步骤\n\n" +
                "要求：\n" +
                "- 建议要具体可执行\n" +
                "- 针对识别出的困难点给出解决方案\n" +
                "- 建议要循序渐进，不要过于激进\n" +
                "- 总字数控制在400字以内\n" +
                "- 使用中文回复";
    }

    /**
     * 构建遗忘风险提示词
     */
    private String buildForgettingRiskPrompt(List<CircleData> memoryData, List<Word> needReviewWords) {
        StringBuilder prompt = new StringBuilder();
        prompt.append("你是一位记忆科学专家，请根据用户的记忆数据分析遗忘风险。\n\n");

        prompt.append("记忆阶段分布：\n");
        for (CircleData data : memoryData) {
            prompt.append("- ").append(data.getType()).append("：").append(String.format("%d", data.getValue()))
                    .append("%\n");
        }

        prompt.append("\n待复习单词数量：").append(needReviewWords.size()).append("个\n\n");

        if (!needReviewWords.isEmpty()) {
            prompt.append("部分待复习单词示例：\n");
            int count = Math.min(5, needReviewWords.size());
            for (int i = 0; i < count; i++) {
                Word word = needReviewWords.get(i);
                prompt.append("- ").append(word.getWord()).append("\n");
            }
            prompt.append("\n");
        }

        prompt.append("请分析：\n");
        prompt.append("1. 当前遗忘风险等级（低/中/高）\n");
        prompt.append("2. 遗忘风险的主要原因\n");
        prompt.append("3. 预防遗忘的具体措施\n");
        prompt.append("4. 建议的复习优先级\n\n");
        prompt.append("要求：\n");
        prompt.append("- 基于艾宾浩斯遗忘曲线理论分析\n");
        prompt.append("- 提供科学依据和解释\n");
        prompt.append("- 总字数控制在300字以内\n");
        prompt.append("- 使用中文回复");

        return prompt.toString();
    }

    /**
     * 分析背诵效率
     * 
     * @param userID     用户ID
     * @param belongBook 所属词书
     * @return 背诵效率分析
     */
    public String analyzeMemorizationEfficiency(String userID, String belongBook) {
        try {
            // 收集效率相关数据
            String efficiencyData = collectEfficiencyData(userID, belongBook);

            // 构建效率分析提示词
            String prompt = buildEfficiencyPrompt(efficiencyData);

            return deepseekService.callDeepseekApi(prompt)
                    .map(response -> {
                        if (response.getChoices() != null && !response.getChoices().isEmpty()) {
                            return response.getChoices().get(0).getMessage().getContent();
                        }
                        return "背诵效率分析失败，请稍后再试。";
                    })
                    .onErrorReturn("AI分析服务暂时不可用，请稍后再试。")
                    .block();

        } catch (Exception e) {
            log.error("分析背诵效率失败: {}", e.getMessage(), e);
            return "背诵效率分析失败，请检查网络连接。";
        }
    }

    /**
     * 分析背诵模式
     * 
     * @param userID 用户ID
     * @return 背诵模式分析
     */
    public String analyzeMemorizationPattern(String userID) {
        try {
            // 收集模式相关数据
            String patternData = collectPatternData(userID);

            // 构建模式分析提示词
            String prompt = buildPatternPrompt(patternData);

            return deepseekService.callDeepseekApi(prompt)
                    .map(response -> {
                        if (response.getChoices() != null && !response.getChoices().isEmpty()) {
                            return response.getChoices().get(0).getMessage().getContent();
                        }
                        return "背诵模式分析失败，请稍后再试。";
                    })
                    .onErrorReturn("AI分析服务暂时不可用，请稍后再试。")
                    .block();

        } catch (Exception e) {
            log.error("分析背诵模式失败: {}", e.getMessage(), e);
            return "背诵模式分析失败，请检查网络连接。";
        }
    }

    /**
     * 分析记忆强度
     * 
     * @param userID     用户ID
     * @param belongBook 所属词书
     * @return 记忆强度分析
     */
    public String analyzeMemoryStrength(String userID, String belongBook) {
        try {
            // 收集记忆强度数据
            String strengthData = collectMemoryStrengthData(userID, belongBook);

            // 构建记忆强度分析提示词
            String prompt = buildMemoryStrengthPrompt(strengthData);

            return deepseekService.callDeepseekApi(prompt)
                    .map(response -> {
                        if (response.getChoices() != null && !response.getChoices().isEmpty()) {
                            return response.getChoices().get(0).getMessage().getContent();
                        }
                        return "记忆强度分析失败，请稍后再试。";
                    })
                    .onErrorReturn("AI分析服务暂时不可用，请稍后再试。")
                    .block();

        } catch (Exception e) {
            log.error("分析记忆强度失败: {}", e.getMessage(), e);
            return "记忆强度分析失败，请检查网络连接。";
        }
    }

    /**
     * 分析学习时间质量
     * 
     * @param userID 用户ID
     * @return 学习时间质量分析
     */
    public String analyzeStudyTimeQuality(String userID) {
        try {
            // 收集时间质量数据
            String qualityData = collectTimeQualityData(userID);

            // 构建时间质量分析提示词
            String prompt = buildTimeQualityPrompt(qualityData);

            return deepseekService.callDeepseekApi(prompt)
                    .map(response -> {
                        if (response.getChoices() != null && !response.getChoices().isEmpty()) {
                            return response.getChoices().get(0).getMessage().getContent();
                        }
                        return "学习时间质量分析失败，请稍后再试。";
                    })
                    .onErrorReturn("AI分析服务暂时不可用，请稍后再试。")
                    .block();

        } catch (Exception e) {
            log.error("分析学习时间质量失败: {}", e.getMessage(), e);
            return "学习时间质量分析失败，请检查网络连接。";
        }
    }

    /**
     * 生成个性化背诵策略
     * 
     * @param userID     用户ID
     * @param belongBook 所属词书
     * @return 个性化背诵策略
     */
    public String generateMemorizationStrategy(String userID, String belongBook) {
        try {
            // 收集用户学习数据
            String userData = collectUserLearningData(userID, belongBook);

            // 收集困难点分析
            String difficulties = analyzeLearningDifficulties(userID);

            // 构建策略生成提示词
            String prompt = buildStrategyPrompt(userData, difficulties);

            return deepseekService.callDeepseekApi(prompt)
                    .map(response -> {
                        if (response.getChoices() != null && !response.getChoices().isEmpty()) {
                            return response.getChoices().get(0).getMessage().getContent();
                        }
                        return "背诵策略生成失败，请稍后再试。";
                    })
                    .onErrorReturn("AI策略服务暂时不可用，请稍后再试。")
                    .block();

        } catch (Exception e) {
            log.error("生成背诵策略失败: {}", e.getMessage(), e);
            return "背诵策略生成失败，请检查网络连接。";
        }
    }

    // 以下是辅助方法

    /**
     * 收集背诵效率数据
     */
    private String collectEfficiencyData(String userID, String belongBook) {
        StringBuilder data = new StringBuilder();

        // 获取学习效率指标
        List<ColumnData> recentData = statisticService.findLatestSevenDaysWordData(userID);
        List<LineData> timeData = statisticService.findLatestSevenDaysTimeData(userID);

        data.append("背诵效率数据分析：\n");

        // 计算平均每分钟背诵单词数
        int totalWords = recentData.stream().mapToInt(ColumnData::getValue).sum();
        int totalTime = timeData.stream().mapToInt(LineData::getTime).sum();

        if (totalTime > 0) {
            double wordsPerMinute = (double) totalWords / totalTime;
            data.append("- 平均背诵效率：").append(String.format("%.2f", wordsPerMinute)).append("个单词/分钟\n");
        }

        data.append("- 7天总背诵单词数：").append(totalWords).append("个\n");
        data.append("- 7天总学习时长：").append(totalTime).append("分钟\n");

        // 分析学习连续性
        long studyDays = timeData.stream().filter(d -> d.getTime() > 0).count();
        data.append("- 学习连续性：7天内有").append(studyDays).append("天进行了学习\n");

        // 分析记忆阶段分布
        List<CircleData> memoryData = statisticService.findMmryPercentage(userID);
        for (CircleData circle : memoryData) {
            if (circle.getPhase() >= 4) { // 掌握、熟悉阶段
                data.append("- 高级记忆阶段占比：").append(String.format("%.1f", circle.getValue())).append("%\n");
                break;
            }
        }

        return data.toString();
    }

    /**
     * 收集背诵模式数据
     */
    private String collectPatternData(String userID) {
        StringBuilder data = new StringBuilder();

        // 获取时间分布数据
        List<LineData> timeData = statisticService.findLatestSevenDaysTimeData(userID);
        List<ColumnData> wordData = statisticService.findLatestSevenDaysWordData(userID);

        data.append("背诵模式数据：\n");

        // 分析学习时长模式
        int[] timePattern = timeData.stream().mapToInt(LineData::getTime).toArray();
        data.append("- 每日学习时长：").append(java.util.Arrays.toString(timePattern)).append("分钟\n");

        // 分析学习强度模式
        Map<String, List<ColumnData>> groupedData = wordData.stream()
                .collect(Collectors.groupingBy(ColumnData::getType));

        if (groupedData.containsKey("Learn")) {
            int[] learnPattern = groupedData.get("Learn").stream().mapToInt(ColumnData::getValue).toArray();
            data.append("- 每日新学单词：").append(java.util.Arrays.toString(learnPattern)).append("个\n");
        }

        if (groupedData.containsKey("Review")) {
            int[] reviewPattern = groupedData.get("Review").stream().mapToInt(ColumnData::getValue).toArray();
            data.append("- 每日复习单词：").append(java.util.Arrays.toString(reviewPattern)).append("个\n");
        }

        // 分析学习偏好
        double avgTime = timeData.stream().mapToInt(LineData::getTime).average().orElse(0);
        if (avgTime > 60) {
            data.append("- 学习偏好：偏向长时间集中学习\n");
        } else if (avgTime > 20) {
            data.append("- 学习偏好：中等时长均衡学习\n");
        } else {
            data.append("- 学习偏好：短时间碎片化学习\n");
        }

        return data.toString();
    }

    /**
     * 收集记忆强度数据
     */
    private String collectMemoryStrengthData(String userID, String belongBook) {
        StringBuilder data = new StringBuilder();

        // 获取记忆阶段分布
        List<CircleData> memoryData = statisticService.findMmryPercentage(userID);
        int learnedCount = statisticService.getLearnedWordCount(userID);
        int totalCount = statisticService.getTotalWordCount(belongBook);
        int reviewCount = statisticService.getNeedReviewWordCount(userID);

        data.append("记忆强度数据：\n");
        data.append("- 总体学习进度：").append(String.format("%.1f", (double) learnedCount / totalCount * 100)).append("%\n");
        data.append("- 待复习单词数：").append(reviewCount).append("个\n");

        // 详细记忆阶段分析
        for (CircleData circle : memoryData) {
            data.append("- ").append(circle.getType()).append("：")
                    .append(String.format("%d", circle.getValue())).append("% (阶段")
                    .append(circle.getPhase()).append(")\n");
        }

        // 计算记忆强度指数
        double strengthIndex = 0;
        for (CircleData circle : memoryData) {
            strengthIndex += circle.getValue() * circle.getPhase() / 100.0;
        }
        data.append("- 综合记忆强度指数：").append(String.format("%.2f", strengthIndex)).append("/6.0\n");

        return data.toString();
    }

    /**
     * 收集学习时间质量数据
     */
    private String collectTimeQualityData(String userID) {
        StringBuilder data = new StringBuilder();

        List<LineData> timeData = statisticService.findLatestSevenDaysTimeData(userID);
        List<ColumnData> wordData = statisticService.findLatestSevenDaysWordData(userID);

        data.append("学习时间质量数据：\n");

        // 计算学习效率
        int totalTime = timeData.stream().mapToInt(LineData::getTime).sum();
        int totalWords = wordData.stream().mapToInt(ColumnData::getValue).sum();

        if (totalTime > 0) {
            double efficiency = (double) totalWords / totalTime;
            data.append("- 学习效率：").append(String.format("%.2f", efficiency)).append("个单词/分钟\n");
        }

        // 分析时间分布质量
        long studyDays = timeData.stream().filter(d -> d.getTime() > 0).count();
        double avgDailyTime = totalTime / 7.0;

        data.append("- 学习频率：7天内").append(studyDays).append("天有学习活动\n");
        data.append("- 平均每日学习时长：").append(String.format("%.1f", avgDailyTime)).append("分钟\n");

        // 计算学习规律性
        int variance = 0;
        for (LineData timeEntry : timeData) {
            variance += Math.pow(timeEntry.getTime() - avgDailyTime, 2);
        }
        double stdDev = Math.sqrt(variance / 7);
        data.append("- 学习时长稳定性：").append(String.format("%.1f", stdDev)).append("（标准差，越小越稳定）\n");

        return data.toString();
    }

    // 提示词构建方法

    private String buildEfficiencyPrompt(String data) {
        return "你是一位专业的学习效率分析师，请根据用户的背诵数据分析学习效率。\n\n" +
                "用户数据：\n" + data + "\n\n" +
                "请从以下角度分析：\n" +
                "1. 当前背诵效率评估（高/中/低）\n" +
                "2. 效率的主要影响因素\n" +
                "3. 提升效率的具体建议\n" +
                "4. 个性化的效率优化方案\n\n" +
                "要求：\n" +
                "- 基于数据给出客观评价\n" +
                "- 建议要具体可执行\n" +
                "- 总字数控制在350字以内\n" +
                "- 使用中文回复";
    }

    private String buildPatternPrompt(String data) {
        return "你是一位学习行为分析专家，请根据用户的学习数据识别背诵模式。\n\n" +
                "学习数据：\n" + data + "\n\n" +
                "请分析：\n" +
                "1. 用户的学习时间模式特征\n" +
                "2. 背诵强度和节奏偏好\n" +
                "3. 学习习惯的优势和劣势\n" +
                "4. 针对性的模式优化建议\n\n" +
                "要求：\n" +
                "- 识别明确的学习模式\n" +
                "- 分析模式的适用性\n" +
                "- 提供模式优化方案\n" +
                "- 总字数控制在300字以内\n" +
                "- 使用中文回复";
    }

    private String buildMemoryStrengthPrompt(String data) {
        return "你是一位记忆科学专家，请根据用户的记忆数据分析记忆强度。\n\n" +
                "记忆数据：\n" + data + "\n\n" +
                "请分析：\n" +
                "1. 当前记忆强度等级评估\n" +
                "2. 各记忆阶段的分布特征\n" +
                "3. 记忆巩固的薄弱环节\n" +
                "4. 强化记忆的针对性建议\n\n" +
                "要求：\n" +
                "- 基于记忆阶段理论分析\n" +
                "- 给出具体的强化方案\n" +
                "- 总字数控制在300字以内\n" +
                "- 使用中文回复";
    }

    private String buildTimeQualityPrompt(String data) {
        return "你是一位时间管理专家，请根据用户的学习时间数据分析时间质量。\n\n" +
                "时间数据：\n" + data + "\n\n" +
                "请分析：\n" +
                "1. 学习时间利用效率评估\n" +
                "2. 时间分配的合理性分析\n" +
                "3. 学习节奏的优化空间\n" +
                "4. 时间管理的改进建议\n\n" +
                "要求：\n" +
                "- 重点关注时间效率\n" +
                "- 提供时间优化策略\n" +
                "- 总字数控制在300字以内\n" +
                "- 使用中文回复";
    }

    private String buildStrategyPrompt(String userData, String difficulties) {
        return "你是一位资深的英语学习策略师，请为用户制定个性化的背诵策略。\n\n" +
                "用户学习数据：\n" + userData + "\n\n" +
                "用户困难点：\n" + difficulties + "\n\n" +
                "请制定策略：\n" +
                "1. 个性化的背诵方法推荐\n" +
                "2. 学习时间和强度安排\n" +
                "3. 复习间隔和频率建议\n" +
                "4. 记忆技巧和助记方法\n" +
                "5. 阶段性目标设定\n\n" +
                "要求：\n" +
                "- 策略要针对用户特点\n" +
                "- 方法要科学可行\n" +
                "- 提供具体操作步骤\n" +
                "- 总字数控制在400字以内\n" +
                "- 使用中文回复";
    }
}
